const express = require('express')

const Music = require('../models/music')
const Songs = require('../models/songs')
const Search = require('../models/search')
const Artist = require('../models/artist')
const Album = require('../models/album')
const User = require('../models/user')
const Collection = require('../models/collection')
const Tag = require('../models/tag')



const router = module.exports = express.Router()

router.prefix = '/api'

/**
 * GET /api/music
 * 所有歌曲
 */
router.get('/music', async(req, res) => {
    // JSONP在当下的WEB开发过程中经常用到，express就是将经常用到的东西进行封装
    // res.send(`${req.query.cb} && ${req.query.cb}(${JSON.stringify(Music.getList())})`)
    // res.send(`foo(${Music.getList()})`)
    // 如果是自己写 必须设置响应的响应类型
    // jsonp方法中会自动接收客户端传来的回调函数名称
    let list = await Music.findAll({
        include: [{ model: Album, as: 'album' }, { model: Artist, as: 'artist' }]
    })
    res.jsonp(list)

})


/**
 * GET /api/music/latest
 * 最新歌曲
 */
router.get('/music/latest', async(req, res) => {

    const list = await Music.findAll({
        limit: 10,
        include: [{ model: Album, as: 'album' }, { model: Artist, as: 'artist' }]
    })
    res.jsonp(list)

})


/**
 * GET /api/music/hot
 * 热歌
 */
router.get('/music/hot', async(req, res) => {

    const list = await Music.findAll({
        limit: 20,
        include: [{ model: Album, as: 'album' }, { model: Artist, as: 'artist' }]
    })
    res.jsonp(list)

})


/**
 * GET /api/music/:id
 * 单个音乐
 */
router.get('/music/:id', async(req, res) => {
    const id = parseInt(req.params.id || 0)
    if (!id) {
        // 不存在这个数据
        return res.status(404).send('没有该记录')
    }
    const music = await Music.findOne({
        where: {
            id: id
        },
        include: [{ model: Album, as: 'album' }, { model: Artist, as: 'artist' }]
    })
    if (!music) {
        // 不存在这个数据
        return res.status(404).send('没有该记录')
    }

    res.jsonp(music)

})





/**
 * GET /api/music/:id
 * 最新歌单
 */
router.get('/songs/latest', async(req, res) => {

    let list = await Songs.findAll({
        limit: 6
    })

    const list1 = list.slice(0, 3);
    const list2 = list.slice(3, 6);

    const result = [
        list1,
        list2
    ]
    res.jsonp(result)


})

/**
 * GET /api/music/:id
 * 单个歌单
 */
router.get('/songs/:id', async(req, res) => {
    const id = parseInt(req.params.id || 0)
    if (!id) {
        // 不存在这个数据
        return res.status(404).send('没有该记录')
    }
    const songs = await Songs.findByPk(id)
    if (!songs) {
        // 不存在这个数据
        return res.status(404).send('没有该记录')
    }

    const user = await User.findByPk(parseInt(songs.userId))
    if (!user) {
        // 不存在这个数据
        return res.status(404).send('没有该记录')
    }

    const musics = await Music.findAll({
        limit: 10,
        include: [{ model: Album, as: 'album' }, { model: Artist, as: 'artist' }]
    })
    if (!musics) {
        // 不存在这个数据
        return res.status(404).send('没有该记录')
    }

    const result = {
        songs: songs,
        list: musics,
        user: user
    }

    res.jsonp(result)
})



/**
 * GET /api/music/:id
 * 所有歌单
 */
router.get('/songs', async(req, res) => {

    const list = await Songs.findAll()
    res.jsonp(list)

})

/**
 * GET /api/search/hot
 * 搜索热词
 */
router.get('/search/hot', async(req, res) => {

    const list = await Search.findAll({
        limit: 20
    })

    res.jsonp(list)

})

/**
 * GET /api/search/hot
 * 搜索匹配
 */
router.get('/search/match/:word', async(req, res) => {
    const word = req.params.word || ''

    if (!word) {
        // 不存在这个数据
        const result = JSON.stringify({
            'code': 400,
            'message': '请输入查询内容'
        })

        res.jsonp(result);

    } else {

        const result = await Search.findAll({
            limlit: 6
        })

        res.jsonp(result)
    }

})

/**
 * GET /api/search/history/:uid
 * 搜索历史
 */
router.get('/search/history/:uid', async(req, res) => {

    const uid = parseInt(req.params.uid || 0)

    if (!uid || uid <= 0) {
        // 不存在这个数据
        const result = JSON.stringify({
            'code': 400,
            'message': '用户不存在'
        })
        res.jsonp(result);

    } else {

        const result = await Search.findAll({
            limlit: 6
        })

        res.jsonp(result)
    }

})

/**
 * GET /search
 * 模糊查询
 */
router.get('/search/:word', async(req, res) => {
    const word = req.params.word

    if (!word) {
        // 不存在这个数据
        const result = JSON.stringify({
            'code': 400,
            'message': '请输入查询内容'
        })
        res.jsonp(result);

    } else {

        const artist = await Artist.findByPk(1)

        const album = await Album.findOne({
            where: {
                id: 1,
            },
            include: { model: Artist, as: 'artist' }
        })

        const musics = await Music.findAll({
            limit: 6,
            include: [{ model: Artist, as: 'artist' }, { model: Album, as: 'album' }]
        })

        const result = {
            artist: artist,
            album: album,
            list: musics
        }

        res.jsonp(result)
    }

})




/**
 * GET /api/user/:id
 * 用户歌单
 */
router.get('/user/songs/:id', async(req, res) => {
    const id = parseInt(req.params.id || 0)
    if (!id) {
        // 不存在这个数据
        return res.status(404).send('没有该记录')
    }

    const list = await Songs.findAll({
        limit: 6
    })

    res.jsonp(list)

})

/**
 * GET /api/user/:id
 * 用户收藏
 */
router.get('/user/collection/:id', async(req, res) => {
    const id = parseInt(req.params.id || 0)
    if (!id) {
        // 不存在这个数据
        return res.status(404).send('没有该记录')
    }

    const collection = await Collection.findOne({
        where: {
            userId: id
        }
    })

    res.jsonp(collection)

})

/**
 * GET /api/user/:id
 * 用户
 */
router.get('/user/:id', async(req, res) => {
    const id = parseInt(req.params.id || 0)
    if (!id) {
        // 不存在这个数据
        return res.status(404).send('没有该记录')
    }
    const user = await User.findByPk(id)
    if (!user) {
        // 不存在这个数据
        return res.status(404).send('没有该记录')
    }

    res.jsonp(user)

})


/**
 * GET /api/artist/:id
 * 歌手
 */
router.get('/artist/:id', async(req, res) => {
    const id = parseInt(req.params.id || 0)
    if (!id) {
        // 不存在这个数据
        return res.status(404).send('没有该记录')
    }
    const artist = await Artist.findByPk(id)
    if (!artist) {
        // 不存在这个数据
        return res.status(404).send('没有该记录')
    }

    const musics = await Music.findAll({
        limit: 20,
        include: [{
                model: Album,
                as: 'album'
            },
            {
                model: Artist,
                as: 'artist'
            },

        ]
    })

    const result = {
        artist: artist,
        musics: musics
    }
    res.jsonp(result)
})

/**
 * GET /api/album/:id
 * 专辑
 */
router.get('/album/:id', async(req, res) => {
    const id = parseInt(req.params.id || 0)
    if (!id) {
        // 不存在这个数据
        return res.status(404).send('没有该记录')
    }
    const album = await Album.findByPk(id)
    if (!album) {
        // 不存在这个数据
        return res.status(404).send('没有该记录')
    }

    const artist = await Artist.findByPk(album.artistId)

    const musics = await Music.findAll({
        limit: 20,
        include: [{
                model: Album,
                as: 'album'
            },
            {
                model: Artist,
                as: 'artist'
            }
        ]
    })

    const result = {
        album: album,
        artist: artist,
        list: musics
    }

    // console.log(result)

    res.jsonp(result)
})




/**
 * GET /api/tag
 * 所有歌单
 */
router.get('/tag', async(req, res) => {

    const list = await Tag.findAll()
    res.jsonp(list)

})